home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / x11 / strategy / xpuzzles.3 / xpuzzles / xpuzzles-5.3.1 / xmball / MballU.c < prev    next >
C/C++ Source or Header  |  1996-02-05  |  7KB  |  267 lines
  1. /*
  2. # X-BASED MASTERBALL(tm)
  3. #
  4. #  MballU.c
  5. #
  6. ###
  7. #
  8. #  Copyright (c) 1994 - 96    David Albert Bagley, bagleyd@hertz.njit.edu
  9. #
  10. #                   All Rights Reserved
  11. #
  12. #  Permission to use, copy, modify, and distribute this software and
  13. #  its documentation for any purpose and without fee is hereby granted,
  14. #  provided that the above copyright notice appear in all copies and
  15. #  that both that copyright notice and this permission notice appear in
  16. #  supporting documentation, and that the name of the author not be
  17. #  used in advertising or publicity pertaining to distribution of the
  18. #  software without specific, written prior permission.
  19. #
  20. #  This program is distributed in the hope that it will be "playable",
  21. #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  22. #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  23. #
  24. */
  25.  
  26. /* Undo algorithm */
  27.  
  28. #include <stdio.h>
  29. #include <stdlib.h>
  30. #include <X11/IntrinsicP.h>
  31. #include <X11/Intrinsic.h>
  32. #include <X11/StringDefs.h>
  33. #include <X11/CoreP.h>
  34. #include "MballP.h"
  35.  
  36. typedef struct _MoveRecord
  37. {
  38.   /* int wedge, direction, control; */
  39.   unsigned short int packed; /* This makes assumptions on the data. */
  40.   int ring; /* Do not make assumptions on this one. */
  41. } MoveRecord;
  42.  
  43. typedef struct _MoveStack
  44. {
  45.   MoveRecord move;
  46.   struct _MoveStack *previous, *next;
  47. } MoveStack;
  48.  
  49. static MoveStack *currMove, *lastMove, *firstMove;
  50. static int count;
  51. MballLoc *startLoc[MAXWEDGES] = {
  52.  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
  53. };
  54.  
  55. static void InitStack();
  56. static void PushStack();
  57. static void PopStack();
  58. static int EmptyStack();
  59. static void FlushStack();
  60.  
  61. static void InitStack()
  62. {
  63.   if (!(lastMove = (MoveStack *) malloc(sizeof(MoveStack))))
  64.     XtError("Not enough memory, exiting.");
  65.   if (!(firstMove = (MoveStack *) malloc(sizeof(MoveStack))))
  66.     XtError("Not enough memory, exiting.");
  67.   firstMove->previous = lastMove->next = NULL;
  68.   firstMove->next = lastMove;
  69.   lastMove->previous = firstMove;
  70.   count = 0;
  71. }
  72.  
  73. static void PushStack(move)
  74.   MoveRecord move;
  75. {
  76.   if (!(currMove = (MoveStack *) malloc(sizeof(MoveStack))))
  77.     XtError("Not enough memory, exiting.");
  78.   lastMove->previous->next = currMove;
  79.   currMove->previous = lastMove->previous;
  80.   currMove->next = lastMove;
  81.   lastMove->previous = currMove;
  82.   currMove->move = move;
  83.   count++;
  84. }
  85.  
  86. static void PopStack(move)
  87.   MoveRecord *move;
  88. {
  89.   *move = lastMove->previous->move;
  90.   currMove = lastMove->previous;
  91.   lastMove->previous->previous->next = lastMove;
  92.   lastMove->previous = lastMove->previous->previous;
  93.   (void) free((void *) currMove);
  94.   count--;
  95. }
  96.  
  97. static int EmptyStack()
  98. {
  99.   return (lastMove->previous == firstMove);
  100. }
  101.  
  102. static void FlushStack()
  103. {
  104.   while (lastMove->previous != firstMove) {
  105.     currMove = lastMove->previous;
  106.     lastMove->previous->previous->next = lastMove;
  107.     lastMove->previous = lastMove->previous->previous;
  108.     (void) free((void *) currMove);
  109.   }
  110.   count = 0;
  111. }
  112.  
  113. /**********************************/
  114.  
  115. void InitMoves()
  116. {
  117.   InitStack();
  118. }
  119.  
  120. static void WriteMove(move, wedge, ring, direction, control)
  121.   MoveRecord *move;
  122.   int wedge, ring, direction, control;
  123. {
  124.   /* move->wedge = wedge; move->direction = direction;
  125.   move->control = control; */
  126.   move->packed = ((control & 0xF) << 8) + ((direction & 0xF) << 4) +
  127.     (wedge & 0xF);
  128.   move->ring = ring;
  129. }
  130.  
  131. static void ReadMove(wedge, ring, direction, control, move)
  132.   int *wedge, *ring, *direction, *control;
  133.   MoveRecord move;
  134. {
  135.   /* *wedge = move.wedge; *direction = move.direction;
  136.   *control = move.control; */
  137.   *wedge = move.packed & 0xF;
  138.   *direction = (move.packed >> 4) & 0xF;
  139.   *control = (move.packed >> 8) & 0xF;
  140.   *ring = move.ring;
  141. }
  142.  
  143. void PutMove(wedge, ring, direction, control)
  144.   int wedge, ring, direction, control;
  145. {
  146.   MoveRecord move;
  147.  
  148.   WriteMove(&move, wedge, ring, direction, control);
  149.   PushStack(move);
  150. }
  151.  
  152. void GetMove(wedge, ring, direction, control)
  153.   int *wedge, *ring, *direction, *control;
  154. {
  155.   MoveRecord move;
  156.  
  157.   PopStack(&move);
  158.   ReadMove(wedge, ring, direction, control, move);
  159. }
  160.  
  161. int MadeMoves()
  162. {
  163.   return !EmptyStack();
  164. }
  165.  
  166. void FlushMoves(w)
  167.   MballWidget w;
  168. {
  169.   int wedge, ring;
  170.  
  171.   FlushStack();
  172.   for (wedge = 0; wedge < w->mball.wedges; wedge++)
  173.     for (ring = 0; ring < w->mball.rings; ring++) {
  174.       startLoc[wedge][ring].wedge =
  175.         w->mball.mballLoc[wedge][ring].wedge;
  176.       startLoc[wedge][ring].direction =
  177.         w->mball.mballLoc[wedge][ring].direction;
  178.     }
  179. }
  180.  
  181. int NumMoves()
  182. {
  183.   return count;
  184. }
  185.  
  186. void ScanMoves(fp, w, moves)
  187.   FILE *fp;
  188.   MballWidget w;
  189.   int moves;
  190. {
  191.   int wedge, ring, direction, control, l;
  192.   char c;
  193.  
  194.   for (l = 0; l < moves; l++) {
  195.     while ((c = getc(fp)) != EOF && c != SYMBOL);
  196.     (void) fscanf(fp, "%d %d %d %d", &wedge, &ring, &direction, &control);
  197.     MoveMball(w, wedge, ring, direction, control);
  198.   }
  199. }
  200.  
  201. void PrintMoves(fp)
  202.   FILE *fp;
  203. {
  204.   int wedge, ring, direction, control, counter = 0;
  205.  
  206.   currMove = firstMove->next;
  207.   (void) fprintf(fp, "moves\twedge\tring\tdir\tcon\n"); 
  208.   while (currMove != lastMove) {
  209.     ReadMove(&wedge, &ring, &direction, &control, currMove->move);
  210.     (void) fprintf(fp, "%d%c\t%d\t%d\t%d\t%d\n",
  211.       ++counter, SYMBOL, wedge, ring, direction, control); 
  212.     currMove = currMove->next;
  213.   }
  214. }
  215.  
  216. void ScanStartPosition(fp, w)       
  217.   FILE *fp;
  218.   MballWidget w;
  219. {
  220.   int wedge, ring, num;
  221.   char c;
  222.  
  223.   while ((c = getc(fp)) != EOF && c != SYMBOL);
  224.   for (wedge = 0; wedge < w->mball.wedges; wedge++)
  225.     for (ring = 0; ring < w->mball.rings; ring++) {
  226.       (void) fscanf(fp, "%d ", &num);
  227.       startLoc[wedge][ring].wedge = num;
  228.       if (w->mball.orient) {
  229.         (void) fscanf(fp, "%d ", &num);
  230.         startLoc[wedge][ring].direction = num;
  231.       }
  232.     }
  233. }
  234.  
  235. void PrintStartPosition(fp, w)       
  236.   FILE *fp;
  237.   MballWidget w;
  238. {
  239.   int wedge, ring;
  240.  
  241.   (void) fprintf(fp, "\nstartingPosition%c\n", SYMBOL);
  242.   for (wedge = 0; wedge < w->mball.wedges; wedge++) {
  243.     for (ring = 0; ring < w->mball.rings; ring++) {
  244.       (void) fprintf(fp, "%d ", startLoc[wedge][ring].wedge);
  245.       if (w->mball.orient)
  246.         (void) fprintf(fp, "%d  ", startLoc[wedge][ring].direction);
  247.     }
  248.     (void) fprintf(fp, "\n");
  249.   }
  250. }
  251.  
  252. void SetStartPosition(w)       
  253.   MballWidget w;
  254. {
  255.   int wedge, ring;
  256.  
  257.   for (wedge = 0; wedge < w->mball.wedges; wedge++)
  258.     for (ring = 0; ring < w->mball.rings; ring++) {
  259.       w->mball.mballLoc[wedge][ring].wedge =
  260.         startLoc[wedge][ring].wedge;
  261.       if (w->mball.orient)
  262.         w->mball.mballLoc[wedge][ring].direction =
  263.           startLoc[wedge][ring].direction;
  264.     }
  265.   DrawAllWedges(w);
  266. }
  267.